var e = "undefined" != typeof window ? window : "undefined" != typeof WorkerGlobalScope && self instanceof WorkerGlobalScope ? self : {}, t = function() {
    var t = /\blang(?:uage)?-([\w-]+)\b/i, a = 0, n = e.Prism = {
        manual: e.Prism && e.Prism.manual,
        disableWorkerMessageHandler: e.Prism && e.Prism.disableWorkerMessageHandler,
        util: {
            encode: function(e) {
                return e instanceof r ? new r(e.type, n.util.encode(e.content), e.alias) : "Array" === n.util.type(e) ? e.map(n.util.encode) : e.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/\u00a0/g, " ");
            },
            type: function(e) {
                return Object.prototype.toString.call(e).match(/\[object (\w+)\]/)[1];
            },
            objId: function(e) {
                return e.__id || Object.defineProperty(e, "__id", {
                    value: ++a
                }), e.__id;
            },
            clone: function(e, t) {
                var a = n.util.type(e);
                switch (t = t || {}, a) {
                  case "Object":
                    if (t[n.util.objId(e)]) return t[n.util.objId(e)];
                    i = {};
                    t[n.util.objId(e)] = i;
                    for (var r in e) e.hasOwnProperty(r) && (i[r] = n.util.clone(e[r], t));
                    return i;

                  case "Array":
                    if (t[n.util.objId(e)]) return t[n.util.objId(e)];
                    var i = [];
                    return t[n.util.objId(e)] = i, e.forEach(function(e, a) {
                        i[a] = n.util.clone(e, t);
                    }), i;
                }
                return e;
            }
        },
        languages: {
            extend: function(e, t) {
                var a = n.util.clone(n.languages[e]);
                for (var r in t) a[r] = t[r];
                return a;
            },
            insertBefore: function(e, t, a, r) {
                var i = (r = r || n.languages)[e];
                if (2 == arguments.length) {
                    a = arguments[1];
                    for (var s in a) a.hasOwnProperty(s) && (i[s] = a[s]);
                    return i;
                }
                var o = {};
                for (var l in i) if (i.hasOwnProperty(l)) {
                    if (l == t) for (var s in a) a.hasOwnProperty(s) && (o[s] = a[s]);
                    o[l] = i[l];
                }
                var u = r[e];
                return r[e] = o, n.languages.DFS(n.languages, function(t, a) {
                    a === u && t != e && (this[t] = o);
                }), o;
            },
            DFS: function(e, t, a, r) {
                r = r || {};
                for (var i in e) e.hasOwnProperty(i) && (t.call(e, i, e[i], a || i), "Object" !== n.util.type(e[i]) || r[n.util.objId(e[i])] ? "Array" !== n.util.type(e[i]) || r[n.util.objId(e[i])] || (r[n.util.objId(e[i])] = !0, 
                n.languages.DFS(e[i], t, i, r)) : (r[n.util.objId(e[i])] = !0, n.languages.DFS(e[i], t, null, r)));
            }
        },
        plugins: {},
        highlightAll: function(e, t) {
            n.highlightAllUnder(document, e, t);
        },
        highlightAllUnder: function(e, t, a) {
            var r = {
                callback: a,
                selector: 'code[class*="language-"], [class*="language-"] code, code[class*="lang-"], [class*="lang-"] code'
            };
            n.hooks.run("before-highlightall", r);
            for (var i, s = r.elements || e.querySelectorAll(r.selector), o = 0; i = s[o++]; ) n.highlightElement(i, !0 === t, r.callback);
        },
        highlightElement: function(a, r, i) {
            for (var s, o, l = a; l && !t.test(l.className); ) l = l.parentNode;
            l && (s = (l.className.match(t) || [ , "" ])[1].toLowerCase(), o = n.languages[s]), 
            a.className = a.className.replace(t, "").replace(/\s+/g, " ") + " language-" + s, 
            a.parentNode && (l = a.parentNode, /pre/i.test(l.nodeName) && (l.className = l.className.replace(t, "").replace(/\s+/g, " ") + " language-" + s));
            var u = {
                element: a,
                language: s,
                grammar: o,
                code: a.textContent
            };
            if (n.hooks.run("before-sanity-check", u), !u.code || !u.grammar) return u.code && (n.hooks.run("before-highlight", u), 
            u.element.textContent = u.code, n.hooks.run("after-highlight", u)), void n.hooks.run("complete", u);
            if (n.hooks.run("before-highlight", u), r && e.Worker) {
                var g = new Worker(n.filename);
                g.onmessage = function(e) {
                    u.highlightedCode = e.data, n.hooks.run("before-insert", u), u.element.innerHTML = u.highlightedCode, 
                    i && i.call(u.element), n.hooks.run("after-highlight", u), n.hooks.run("complete", u);
                }, g.postMessage(JSON.stringify({
                    language: u.language,
                    code: u.code,
                    immediateClose: !0
                }));
            } else u.highlightedCode = n.highlight(u.code, u.grammar, u.language), n.hooks.run("before-insert", u), 
            u.element.innerHTML = u.highlightedCode, i && i.call(a), n.hooks.run("after-highlight", u), 
            n.hooks.run("complete", u);
        },
        highlight: function(e, t, a) {
            var i = {
                code: e,
                grammar: t,
                language: a
            };
            return n.hooks.run("before-tokenize", i), i.tokens = n.tokenize(i.code, i.grammar), 
            n.hooks.run("after-tokenize", i), r.stringify(n.util.encode(i.tokens), i.language);
        },
        matchGrammar: function(e, t, a, r, i, s, o) {
            var l = n.Token;
            for (var u in a) if (a.hasOwnProperty(u) && a[u]) {
                if (u == o) return;
                var g = a[u];
                g = "Array" === n.util.type(g) ? g : [ g ];
                for (var c = 0; c < g.length; ++c) {
                    var d = g[c], p = d.inside, h = !!d.lookbehind, f = !!d.greedy, m = 0, b = d.alias;
                    if (f && !d.pattern.global) {
                        var k = d.pattern.toString().match(/[imuy]*$/)[0];
                        d.pattern = RegExp(d.pattern.source, k + "g");
                    }
                    d = d.pattern || d;
                    for (var y = r, w = i; y < t.length; w += t[y].length, ++y) {
                        var v = t[y];
                        if (t.length > e.length) return;
                        if (!(v instanceof l)) {
                            if (f && y != t.length - 1) {
                                if (d.lastIndex = w, !(j = d.exec(e))) break;
                                for (var _ = j.index + (h ? j[1].length : 0), x = j.index + j[0].length, F = y, S = w, A = t.length; A > F && (x > S || !t[F].type && !t[F - 1].greedy); ++F) _ >= (S += t[F].length) && (++y, 
                                w = S);
                                if (t[y] instanceof l) continue;
                                $ = F - y, v = e.slice(w, S), j.index -= w;
                            } else {
                                d.lastIndex = 0;
                                var j = d.exec(v), $ = 1;
                            }
                            if (j) {
                                h && (m = j[1] ? j[1].length : 0);
                                var x = (_ = j.index + m) + (j = j[0].slice(m)).length, z = v.slice(0, _), P = v.slice(x), B = [ y, $ ];
                                z && (++y, w += z.length, B.push(z));
                                var O = new l(u, p ? n.tokenize(j, p) : j, b, j, f);
                                if (B.push(O), P && B.push(P), Array.prototype.splice.apply(t, B), 1 != $ && n.matchGrammar(e, t, a, y, w, !0, u), 
                                s) break;
                            } else if (s) break;
                        }
                    }
                }
            }
        },
        tokenize: function(e, t) {
            var a = [ e ], r = t.rest;
            if (r) {
                for (var i in r) t[i] = r[i];
                delete t.rest;
            }
            return n.matchGrammar(e, a, t, 0, 0, !1), a;
        },
        hooks: {
            all: {},
            add: function(e, t) {
                var a = n.hooks.all;
                a[e] = a[e] || [], a[e].push(t);
            },
            run: function(e, t) {
                var a = n.hooks.all[e];
                if (a && a.length) for (var r, i = 0; r = a[i++]; ) r(t);
            }
        }
    }, r = n.Token = function(e, t, a, n, r) {
        this.type = e, this.content = t, this.alias = a, this.length = 0 | (n || "").length, 
        this.greedy = !!r;
    };
    if (r.stringify = function(e, t, a) {
        if ("string" == typeof e) return e;
        if ("Array" === n.util.type(e)) return e.map(function(a) {
            return r.stringify(a, t, e);
        }).join("");
        var i = {
            type: e.type,
            content: r.stringify(e.content, t, a),
            tag: "span",
            classes: [ "token", e.type ],
            attributes: {},
            language: t,
            parent: a
        };
        if (e.alias) {
            var s = "Array" === n.util.type(e.alias) ? e.alias : [ e.alias ];
            Array.prototype.push.apply(i.classes, s);
        }
        n.hooks.run("wrap", i);
        var o = Object.keys(i.attributes).map(function(e) {
            return e + '="' + (i.attributes[e] || "").replace(/"/g, "&quot;") + '"';
        }).join(" ");
        return "<" + i.tag + ' class="' + i.classes.join(" ") + '"' + (o ? " " + o : "") + ">" + i.content + "</" + i.tag + ">";
    }, !e.document) return e.addEventListener ? (n.disableWorkerMessageHandler || e.addEventListener("message", function(t) {
        var a = JSON.parse(t.data), r = a.language, i = a.code, s = a.immediateClose;
        e.postMessage(n.highlight(i, n.languages[r], r)), s && e.close();
    }, !1), e.Prism) : e.Prism;
    var i = document.currentScript || [].slice.call(document.getElementsByTagName("script")).pop();
    return i && (n.filename = i.src, n.manual || i.hasAttribute("data-manual") || ("loading" !== document.readyState ? window.requestAnimationFrame ? window.requestAnimationFrame(n.highlightAll) : window.setTimeout(n.highlightAll, 16) : document.addEventListener("DOMContentLoaded", n.highlightAll))), 
    e.Prism;
}();

"undefined" != typeof module && module.exports && (module.exports = t), "undefined" != typeof global && (global.Prism = t), 
t.languages.markup = {
    comment: /<!--[\s\S]*?-->/,
    prolog: /<\?[\s\S]+?\?>/,
    doctype: /<!DOCTYPE[\s\S]+?>/i,
    cdata: /<!\[CDATA\[[\s\S]*?]]>/i,
    tag: {
        pattern: /<\/?(?!\d)[^\s>\/=$<%]+(?:\s+[^\s>\/=]+(?:=(?:("|')(?:\\[\s\S]|(?!\1)[^\\])*\1|[^\s'">=]+))?)*\s*\/?>/i,
        greedy: !0,
        inside: {
            tag: {
                pattern: /^<\/?[^\s>\/]+/i,
                inside: {
                    punctuation: /^<\/?/,
                    namespace: /^[^\s>\/:]+:/
                }
            },
            "attr-value": {
                pattern: /=(?:("|')(?:\\[\s\S]|(?!\1)[^\\])*\1|[^\s'">=]+)/i,
                inside: {
                    punctuation: [ /^=/, {
                        pattern: /(^|[^\\])["']/,
                        lookbehind: !0
                    } ]
                }
            },
            punctuation: /\/?>/,
            "attr-name": {
                pattern: /[^\s>\/]+/,
                inside: {
                    namespace: /^[^\s>\/:]+:/
                }
            }
        }
    },
    entity: /&#?[\da-z]{1,8};/i
}, t.languages.markup.tag.inside["attr-value"].inside.entity = t.languages.markup.entity, 
t.hooks.add("wrap", function(e) {
    "entity" === e.type && (e.attributes.title = e.content.replace(/&amp;/, "&"));
}), t.languages.xml = t.languages.markup, t.languages.html = t.languages.markup, 
t.languages.mathml = t.languages.markup, t.languages.svg = t.languages.markup, t.languages.css = {
    comment: /\/\*[\s\S]*?\*\//,
    atrule: {
        pattern: /@[\w-]+?.*?(?:;|(?=\s*\{))/i,
        inside: {
            rule: /@[\w-]+/
        }
    },
    url: /url\((?:(["'])(?:\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1|.*?)\)/i,
    selector: /[^{}\s][^{};]*?(?=\s*\{)/,
    string: {
        pattern: /("|')(?:\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1/,
        greedy: !0
    },
    property: /[-_a-z\xA0-\uFFFF][-\w\xA0-\uFFFF]*(?=\s*:)/i,
    important: /\B!important\b/i,
    function: /[-a-z0-9]+(?=\()/i,
    punctuation: /[(){};:]/
}, t.languages.css.atrule.inside.rest = t.languages.css, t.languages.markup && (t.languages.insertBefore("markup", "tag", {
    style: {
        pattern: /(<style[\s\S]*?>)[\s\S]*?(?=<\/style>)/i,
        lookbehind: !0,
        inside: t.languages.css,
        alias: "language-css",
        greedy: !0
    }
}), t.languages.insertBefore("inside", "attr-value", {
    "style-attr": {
        pattern: /\s*style=("|')(?:\\[\s\S]|(?!\1)[^\\])*\1/i,
        inside: {
            "attr-name": {
                pattern: /^\s*style/i,
                inside: t.languages.markup.tag.inside
            },
            punctuation: /^\s*=\s*['"]|['"]\s*$/,
            "attr-value": {
                pattern: /.+/i,
                inside: t.languages.css
            }
        },
        alias: "language-css"
    }
}, t.languages.markup.tag)), t.languages.clike = {
    comment: [ {
        pattern: /(^|[^\\])\/\*[\s\S]*?(?:\*\/|$)/,
        lookbehind: !0
    }, {
        pattern: /(^|[^\\:])\/\/.*/,
        lookbehind: !0,
        greedy: !0
    } ],
    string: {
        pattern: /(["'])(?:\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1/,
        greedy: !0
    },
    "class-name": {
        pattern: /((?:\b(?:class|interface|extends|implements|trait|instanceof|new)\s+)|(?:catch\s+\())[\w.\\]+/i,
        lookbehind: !0,
        inside: {
            punctuation: /[.\\]/
        }
    },
    keyword: /\b(?:if|else|while|do|for|return|in|instanceof|function|new|try|throw|catch|finally|null|break|continue)\b/,
    boolean: /\b(?:true|false)\b/,
    function: /[a-z0-9_]+(?=\()/i,
    number: /\b0x[\da-f]+\b|(?:\b\d+\.?\d*|\B\.\d+)(?:e[+-]?\d+)?/i,
    operator: /--?|\+\+?|!=?=?|<=?|>=?|==?=?|&&?|\|\|?|\?|\*|\/|~|\^|%/,
    punctuation: /[{}[\];(),.:]/
}, t.languages.javascript = t.languages.extend("clike", {
    "class-name": [ t.languages.clike["class-name"], /[_$A-Z\xA0-\uFFFF][$\w\xA0-\uFFFF]*(?=\.(?:prototype|constructor))/ ],
    keyword: [ {
        pattern: /((?:^|})\s*)(?:catch|finally)\b/,
        lookbehind: !0
    }, /\b(?:as|async|await|break|case|class|const|continue|debugger|default|delete|do|else|enum|export|extends|for|from|function|get|if|implements|import|in|instanceof|interface|let|new|null|of|package|private|protected|public|return|set|static|super|switch|this|throw|try|typeof|var|void|while|with|yield)\b/ ],
    number: /\b(?:0[xX][\dA-Fa-f]+|0[bB][01]+|0[oO][0-7]+|NaN|Infinity)\b|(?:\b\d+\.?\d*|\B\.\d+)(?:[Ee][+-]?\d+)?/,
    function: /[_$a-zA-Z\xA0-\uFFFF][$\w\xA0-\uFFFF]*(?=\s*\(|\.(?:apply|bind|call)\()/,
    operator: /-[-=]?|\+[+=]?|!=?=?|<<?=?|>>?>?=?|=(?:==?|>)?|&[&=]?|\|[|=]?|\*\*?=?|\/=?|~|\^=?|%=?|\?|\.{3}/
}), t.languages.javascript["class-name"][0].pattern = /(\b(?:class|interface|extends|implements|instanceof|new)\s+)[\w.\\]+/, 
t.languages.insertBefore("javascript", "keyword", {
    regex: {
        pattern: /((?:^|[^$\w\xA0-\uFFFF."'\])\s])\s*)\/(\[[^\]\r\n]+]|\\.|[^\/\\\[\r\n])+\/[gimyu]{0,5}(?=\s*($|[\r\n,.;})\]]))/,
        lookbehind: !0,
        greedy: !0
    },
    "function-variable": {
        pattern: /[_$a-z\xA0-\uFFFF][$\w\xA0-\uFFFF]*(?=\s*[=:]\s*(?:function\b|(?:\([^()]*\)|[_$a-z\xA0-\uFFFF][$\w\xA0-\uFFFF]*)\s*=>))/i,
        alias: "function"
    },
    constant: /\b[A-Z][A-Z\d_]*\b/
}), t.languages.insertBefore("javascript", "string", {
    "template-string": {
        pattern: /`(?:\\[\s\S]|\${[^}]+}|[^\\`])*`/,
        greedy: !0,
        inside: {
            interpolation: {
                pattern: /\${[^}]+}/,
                inside: {
                    "interpolation-punctuation": {
                        pattern: /^\${|}$/,
                        alias: "punctuation"
                    },
                    rest: t.languages.javascript
                }
            },
            string: /[\s\S]+/
        }
    }
}), t.languages.markup && t.languages.insertBefore("markup", "tag", {
    script: {
        pattern: /(<script[\s\S]*?>)[\s\S]*?(?=<\/script>)/i,
        lookbehind: !0,
        inside: t.languages.javascript,
        alias: "language-javascript",
        greedy: !0
    }
}), t.languages.js = t.languages.javascript, t.languages["markup-templating"] = {}, 
Object.defineProperties(t.languages["markup-templating"], {
    buildPlaceholders: {
        value: function(e, a, n, r) {
            e.language === a && (e.tokenStack = [], e.code = e.code.replace(n, function(t) {
                if ("function" == typeof r && !r(t)) return t;
                for (var n = e.tokenStack.length; -1 !== e.code.indexOf("___" + a.toUpperCase() + n + "___"); ) ++n;
                return e.tokenStack[n] = t, "___" + a.toUpperCase() + n + "___";
            }), e.grammar = t.languages.markup);
        }
    },
    tokenizePlaceholders: {
        value: function(e, a) {
            if (e.language === a && e.tokenStack) {
                e.grammar = t.languages[a];
                var n = 0, r = Object.keys(e.tokenStack);
                !function i(s) {
                    if (!(n >= r.length)) for (var o = 0; o < s.length; o++) {
                        var l = s[o];
                        if ("string" == typeof l || l.content && "string" == typeof l.content) {
                            var u = r[n], g = e.tokenStack[u], c = "string" == typeof l ? l : l.content, d = c.indexOf("___" + a.toUpperCase() + u + "___");
                            if (d > -1) {
                                ++n;
                                var p, h = c.substring(0, d), f = new t.Token(a, t.tokenize(g, e.grammar, a), "language-" + a, g), m = c.substring(d + ("___" + a.toUpperCase() + u + "___").length);
                                if (h || m ? (p = [ h, f, m ].filter(function(e) {
                                    return !!e;
                                }), i(p)) : p = f, "string" == typeof l ? Array.prototype.splice.apply(s, [ o, 1 ].concat(p)) : l.content = p, 
                                n >= r.length) break;
                            }
                        } else l.content && "string" != typeof l.content && i(l.content);
                    }
                }(e.tokens);
            }
        }
    }
}), t.languages.java = t.languages.extend("clike", {
    keyword: /\b(?:abstract|continue|for|new|switch|assert|default|goto|package|synchronized|boolean|do|if|private|this|break|double|implements|protected|throw|byte|else|import|public|throws|case|enum|instanceof|return|transient|catch|extends|int|short|try|char|final|interface|static|void|class|finally|long|strictfp|volatile|const|float|native|super|while)\b/,
    number: /\b0b[01]+\b|\b0x[\da-f]*\.?[\da-fp-]+\b|(?:\b\d+\.?\d*|\B\.\d+)(?:e[+-]?\d+)?[df]?/i,
    operator: {
        pattern: /(^|[^.])(?:<<=?|>>>?=?|->|([-+&|])\2|[?:~]|[-+*\/%&|^!=<>]=?)/m,
        lookbehind: !0
    }
}), t.languages.insertBefore("java", "function", {
    annotation: {
        alias: "punctuation",
        pattern: /(^|[^.])@\w+/,
        lookbehind: !0
    }
}), t.languages.insertBefore("java", "class-name", {
    generics: {
        pattern: /<\s*\w+(?:\.\w+)?(?:\s*,\s*\w+(?:\.\w+)?)*>/i,
        alias: "function",
        inside: {
            keyword: t.languages.java.keyword,
            punctuation: /[<>(),.:]/
        }
    }
}), t.languages.markdown = t.languages.extend("markup", {}), t.languages.insertBefore("markdown", "prolog", {
    blockquote: {
        pattern: /^>(?:[\t ]*>)*/m,
        alias: "punctuation"
    },
    code: [ {
        pattern: /^(?: {4}|\t).+/m,
        alias: "keyword"
    }, {
        pattern: /``.+?``|`[^`\n]+`/,
        alias: "keyword"
    } ],
    title: [ {
        pattern: /\w+.*(?:\r?\n|\r)(?:==+|--+)/,
        alias: "important",
        inside: {
            punctuation: /==+$|--+$/
        }
    }, {
        pattern: /(^\s*)#+.+/m,
        lookbehind: !0,
        alias: "important",
        inside: {
            punctuation: /^#+|#+$/
        }
    } ],
    hr: {
        pattern: /(^\s*)([*-])(?:[\t ]*\2){2,}(?=\s*$)/m,
        lookbehind: !0,
        alias: "punctuation"
    },
    list: {
        pattern: /(^\s*)(?:[*+-]|\d+\.)(?=[\t ].)/m,
        lookbehind: !0,
        alias: "punctuation"
    },
    "url-reference": {
        pattern: /!?\[[^\]]+\]:[\t ]+(?:\S+|<(?:\\.|[^>\\])+>)(?:[\t ]+(?:"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|\((?:\\.|[^)\\])*\)))?/,
        inside: {
            variable: {
                pattern: /^(!?\[)[^\]]+/,
                lookbehind: !0
            },
            string: /(?:"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|\((?:\\.|[^)\\])*\))$/,
            punctuation: /^[\[\]!:]|[<>]/
        },
        alias: "url"
    },
    bold: {
        pattern: /(^|[^\\])(\*\*|__)(?:(?:\r?\n|\r)(?!\r?\n|\r)|.)+?\2/,
        lookbehind: !0,
        inside: {
            punctuation: /^\*\*|^__|\*\*$|__$/
        }
    },
    italic: {
        pattern: /(^|[^\\])([*_])(?:(?:\r?\n|\r)(?!\r?\n|\r)|.)+?\2/,
        lookbehind: !0,
        inside: {
            punctuation: /^[*_]|[*_]$/
        }
    },
    url: {
        pattern: /!?\[[^\]]+\](?:\([^\s)]+(?:[\t ]+"(?:\\.|[^"\\])*")?\)| ?\[[^\]\n]*\])/,
        inside: {
            variable: {
                pattern: /(!?\[)[^\]]+(?=\]$)/,
                lookbehind: !0
            },
            string: {
                pattern: /"(?:\\.|[^"\\])*"(?=\)$)/
            }
        }
    }
}), t.languages.markdown.bold.inside.url = t.languages.markdown.url, t.languages.markdown.italic.inside.url = t.languages.markdown.url, 
t.languages.markdown.bold.inside.italic = t.languages.markdown.italic, t.languages.markdown.italic.inside.bold = t.languages.markdown.bold, 
function(e) {
    e.languages.php = e.languages.extend("clike", {
        keyword: /\b(?:and|or|xor|array|as|break|case|cfunction|class|const|continue|declare|default|die|do|else|elseif|enddeclare|endfor|endforeach|endif|endswitch|endwhile|extends|for|foreach|function|include|include_once|global|if|new|return|static|switch|use|require|require_once|var|while|abstract|interface|public|implements|private|protected|parent|throw|null|echo|print|trait|namespace|final|yield|goto|instanceof|finally|try|catch)\b/i,
        constant: /\b[A-Z0-9_]{2,}\b/,
        comment: {
            pattern: /(^|[^\\])(?:\/\*[\s\S]*?\*\/|\/\/.*)/,
            lookbehind: !0
        }
    }), e.languages.insertBefore("php", "string", {
        "shell-comment": {
            pattern: /(^|[^\\])#.*/,
            lookbehind: !0,
            alias: "comment"
        }
    }), e.languages.insertBefore("php", "keyword", {
        delimiter: {
            pattern: /\?>|<\?(?:php|=)?/i,
            alias: "important"
        },
        variable: /\$+(?:\w+\b|(?={))/i,
        package: {
            pattern: /(\\|namespace\s+|use\s+)[\w\\]+/,
            lookbehind: !0,
            inside: {
                punctuation: /\\/
            }
        }
    }), e.languages.insertBefore("php", "operator", {
        property: {
            pattern: /(->)[\w]+/,
            lookbehind: !0
        }
    });
    var t = {
        pattern: /{\$(?:{(?:{[^{}]+}|[^{}]+)}|[^{}])+}|(^|[^\\{])\$+(?:\w+(?:\[.+?]|->\w+)*)/,
        lookbehind: !0,
        inside: {
            rest: e.languages.php
        }
    };
    e.languages.insertBefore("php", "string", {
        "nowdoc-string": {
            pattern: /<<<'([^']+)'(?:\r\n?|\n)(?:.*(?:\r\n?|\n))*?\1;/,
            greedy: !0,
            alias: "string",
            inside: {
                delimiter: {
                    pattern: /^<<<'[^']+'|[a-z_]\w*;$/i,
                    alias: "symbol",
                    inside: {
                        punctuation: /^<<<'?|[';]$/
                    }
                }
            }
        },
        "heredoc-string": {
            pattern: /<<<(?:"([^"]+)"(?:\r\n?|\n)(?:.*(?:\r\n?|\n))*?\1;|([a-z_]\w*)(?:\r\n?|\n)(?:.*(?:\r\n?|\n))*?\2;)/i,
            greedy: !0,
            alias: "string",
            inside: {
                delimiter: {
                    pattern: /^<<<(?:"[^"]+"|[a-z_]\w*)|[a-z_]\w*;$/i,
                    alias: "symbol",
                    inside: {
                        punctuation: /^<<<"?|[";]$/
                    }
                },
                interpolation: t
            }
        },
        "single-quoted-string": {
            pattern: /'(?:\\[\s\S]|[^\\'])*'/,
            greedy: !0,
            alias: "string"
        },
        "double-quoted-string": {
            pattern: /"(?:\\[\s\S]|[^\\"])*"/,
            greedy: !0,
            alias: "string",
            inside: {
                interpolation: t
            }
        }
    }), delete e.languages.php.string, e.hooks.add("before-tokenize", function(t) {
        if (/(?:<\?php|<\?)/gi.test(t.code)) {
            var a = /(?:<\?php|<\?)[\s\S]*?(?:\?>|$)/gi;
            e.languages["markup-templating"].buildPlaceholders(t, "php", a);
        }
    }), e.hooks.add("after-tokenize", function(t) {
        e.languages["markup-templating"].tokenizePlaceholders(t, "php");
    });
}(t), t.languages.python = {
    comment: {
        pattern: /(^|[^\\])#.*/,
        lookbehind: !0
    },
    "triple-quoted-string": {
        pattern: /("""|''')[\s\S]+?\1/,
        greedy: !0,
        alias: "string"
    },
    string: {
        pattern: /("|')(?:\\.|(?!\1)[^\\\r\n])*\1/,
        greedy: !0
    },
    function: {
        pattern: /((?:^|\s)def[ \t]+)[a-zA-Z_]\w*(?=\s*\()/g,
        lookbehind: !0
    },
    "class-name": {
        pattern: /(\bclass\s+)\w+/i,
        lookbehind: !0
    },
    keyword: /\b(?:as|assert|async|await|break|class|continue|def|del|elif|else|except|exec|finally|for|from|global|if|import|in|is|lambda|nonlocal|pass|print|raise|return|try|while|with|yield)\b/,
    builtin: /\b(?:__import__|abs|all|any|apply|ascii|basestring|bin|bool|buffer|bytearray|bytes|callable|chr|classmethod|cmp|coerce|compile|complex|delattr|dict|dir|divmod|enumerate|eval|execfile|file|filter|float|format|frozenset|getattr|globals|hasattr|hash|help|hex|id|input|int|intern|isinstance|issubclass|iter|len|list|locals|long|map|max|memoryview|min|next|object|oct|open|ord|pow|property|range|raw_input|reduce|reload|repr|reversed|round|set|setattr|slice|sorted|staticmethod|str|sum|super|tuple|type|unichr|unicode|vars|xrange|zip)\b/,
    boolean: /\b(?:True|False|None)\b/,
    number: /(?:\b(?=\d)|\B(?=\.))(?:0[bo])?(?:(?:\d|0x[\da-f])[\da-f]*\.?\d*|\.\d+)(?:e[+-]?\d+)?j?\b/i,
    operator: /[-+%=]=?|!=|\*\*?=?|\/\/?=?|<[<=>]?|>[=>]?|[&|^~]|\b(?:or|and|not)\b/,
    punctuation: /[{}[\];(),.:]/
};